// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima).
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

/*!
 * @file test_modules.i
 * This header file contains the SWIG interface of the described types in the IDL file.
 *
 * This file was generated by the tool fastddsgen.
 */

%module test_modules

// SWIG helper modules
%include "stdint.i"
%include "std_array.i"
%include "std_map.i"
%include "std_string.i"
%include "std_vector.i"
%include "typemaps.i"

// Assignemt operators are ignored, as there is no such thing in Python.
// Trying to export them issues a warning
%ignore *::operator=;

// Macro declarations
// Any macro used on the Fast DDS header files will give an error if it is not redefined here
#define RTPS_DllAPI
#define eProsima_user_DllExport


%{
#include "test_modules.h"

#include <fastdds/dds/core/LoanableSequence.hpp>
%}

%include <fastcdr/config.h>
#if FASTCDR_VERSION_MAJOR > 1
%import(module="fastdds") "fastcdr/xcdr/optional.hpp"
#endif
%import(module="fastdds") "fastdds/dds/core/LoanableCollection.hpp"
%import(module="fastdds") "fastdds/dds/core/LoanableTypedCollection.hpp"
%import(module="fastdds") "fastdds/dds/core/LoanableSequence.hpp"

%define %traits_penumn(Type...)
  %fragment(SWIG_Traits_frag(Type),"header",
        fragment="StdTraits") {
namespace swig {
  template <> struct traits< Type > {
    typedef value_category category;
    static const char* type_name() { return  #Type; }
  };
}
}
%enddef

%traits_penumn(enum eprosima::test::Color);
%traits_penumn(enum eprosima::test::Material);


////////////////////////////////////////////////////////
// Binding for class eprosima::test::StructType
////////////////////////////////////////////////////////

// Ignore overloaded methods that have no application on Python
// Otherwise they will issue a warning
%ignore eprosima::test::StructType::StructType(eprosima::test::StructType&&);

// Overloaded getter methods shadow each other and are equivalent in python
// Avoid a warning ignoring all but one
%ignore eprosima::test::StructType::char_field(char&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::StructType::char_field();
%rename("%s") eprosima::test::StructType::char_field() const;



%ignore eprosima::test::StructType::uint8_field(uint8_t&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::StructType::uint8_field();
%rename("%s") eprosima::test::StructType::uint8_field() const;



%ignore eprosima::test::StructType::int16_field(int16_t&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::StructType::int16_field();
%rename("%s") eprosima::test::StructType::int16_field() const;



%ignore eprosima::test::StructType::uint16_field(uint16_t&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::StructType::uint16_field();
%rename("%s") eprosima::test::StructType::uint16_field() const;



%ignore eprosima::test::StructType::int32_field(int32_t&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::StructType::int32_field();
%rename("%s") eprosima::test::StructType::int32_field() const;



%ignore eprosima::test::StructType::uint32_field(uint32_t&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::StructType::uint32_field();
%rename("%s") eprosima::test::StructType::uint32_field() const;



%ignore eprosima::test::StructType::int64_field(int64_t&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::StructType::int64_field();
%rename("%s") eprosima::test::StructType::int64_field() const;



%ignore eprosima::test::StructType::uint64_field(uint64_t&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::StructType::uint64_field();
%rename("%s") eprosima::test::StructType::uint64_field() const;



%ignore eprosima::test::StructType::float_field(float&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::StructType::float_field();
%rename("%s") eprosima::test::StructType::float_field() const;



%ignore eprosima::test::StructType::double_field(double&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::StructType::double_field();
%rename("%s") eprosima::test::StructType::double_field() const;



%ignore eprosima::test::StructType::bool_field(bool&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::StructType::bool_field();
%rename("%s") eprosima::test::StructType::bool_field() const;



%ignore eprosima::test::StructType::string_field(std::string&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::StructType::string_field();
%rename("%s") eprosima::test::StructType::string_field() const;



%ignore eprosima::test::StructType::enum_field(eprosima::test::Color&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::StructType::enum_field();
%rename("%s") eprosima::test::StructType::enum_field() const;



%ignore eprosima::test::StructType::enum2_field(eprosima::test::Material&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::StructType::enum2_field();
%rename("%s") eprosima::test::StructType::enum2_field() const;



%template(_StructTypeSeq) eprosima::fastdds::dds::LoanableTypedCollection<eprosima::test::StructType, std::false_type>;
%template(StructTypeSeq) eprosima::fastdds::dds::LoanableSequence<eprosima::test::StructType, std::false_type>;
%extend eprosima::fastdds::dds::LoanableSequence<eprosima::test::StructType, std::false_type>
{
    size_t __len__() const
    {
        return self->length();
    }

    const eprosima::test::StructType& __getitem__(size_t i) const
    {
        return (*self)[i];
    }
}









////////////////////////////////////////////////////////
// Binding for class eprosima::test::CompleteTestType
////////////////////////////////////////////////////////

// Ignore overloaded methods that have no application on Python
// Otherwise they will issue a warning
%ignore eprosima::test::CompleteTestType::CompleteTestType(eprosima::test::CompleteTestType&&);

// Overloaded getter methods shadow each other and are equivalent in python
// Avoid a warning ignoring all but one
%ignore eprosima::test::CompleteTestType::char_field(char&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::char_field();
%rename("%s") eprosima::test::CompleteTestType::char_field() const;



%ignore eprosima::test::CompleteTestType::uint8_field(uint8_t&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::uint8_field();
%rename("%s") eprosima::test::CompleteTestType::uint8_field() const;



%ignore eprosima::test::CompleteTestType::int16_field(int16_t&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::int16_field();
%rename("%s") eprosima::test::CompleteTestType::int16_field() const;



%ignore eprosima::test::CompleteTestType::uint16_field(uint16_t&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::uint16_field();
%rename("%s") eprosima::test::CompleteTestType::uint16_field() const;



%ignore eprosima::test::CompleteTestType::int32_field(int32_t&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::int32_field();
%rename("%s") eprosima::test::CompleteTestType::int32_field() const;



%ignore eprosima::test::CompleteTestType::uint32_field(uint32_t&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::uint32_field();
%rename("%s") eprosima::test::CompleteTestType::uint32_field() const;



%ignore eprosima::test::CompleteTestType::int64_field(int64_t&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::int64_field();
%rename("%s") eprosima::test::CompleteTestType::int64_field() const;



%ignore eprosima::test::CompleteTestType::uint64_field(uint64_t&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::uint64_field();
%rename("%s") eprosima::test::CompleteTestType::uint64_field() const;



%ignore eprosima::test::CompleteTestType::float_field(float&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::float_field();
%rename("%s") eprosima::test::CompleteTestType::float_field() const;



%ignore eprosima::test::CompleteTestType::double_field(double&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::double_field();
%rename("%s") eprosima::test::CompleteTestType::double_field() const;



%ignore eprosima::test::CompleteTestType::bool_field(bool&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::bool_field();
%rename("%s") eprosima::test::CompleteTestType::bool_field() const;



%ignore eprosima::test::CompleteTestType::string_field(std::string&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::string_field();
%rename("%s") eprosima::test::CompleteTestType::string_field() const;



%ignore eprosima::test::CompleteTestType::enum_field(eprosima::test::Color&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::enum_field();
%rename("%s") eprosima::test::CompleteTestType::enum_field() const;



%ignore eprosima::test::CompleteTestType::enum2_field(eprosima::test::Material&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::enum2_field();
%rename("%s") eprosima::test::CompleteTestType::enum2_field() const;



%ignore eprosima::test::CompleteTestType::struct_field(eprosima::test::StructType&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::struct_field();
%rename("%s") eprosima::test::CompleteTestType::struct_field() const;



#if FASTCDR_VERSION_MAJOR == 1
%ignore eprosima::test::CompleteTestType::char_opt_field(char&&);
#else
%ignore eprosima::fastcdr::optional::value;
%ignore eprosima::fastcdr::optional::reset;
%template(charOpt) eprosima::fastcdr::optional<char>;
%extend eprosima::fastcdr::optional<char> {
  char get_value() const {
      return $self->value();
  }

  void set_value(const char& value) {
      *$self = value;
  }
}
%ignore eprosima::test::CompleteTestType::char_opt_field(eprosima::fastcdr::optional<char>&&);
#endif

// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::char_opt_field();
%rename("%s") eprosima::test::CompleteTestType::char_opt_field() const;



#if FASTCDR_VERSION_MAJOR == 1
%ignore eprosima::test::CompleteTestType::uint8_opt_field(uint8_t&&);
#else
%ignore eprosima::fastcdr::optional::value;
%ignore eprosima::fastcdr::optional::reset;
%template(uint8_tOpt) eprosima::fastcdr::optional<uint8_t>;
%extend eprosima::fastcdr::optional<uint8_t> {
  uint8_t get_value() const {
      return $self->value();
  }

  void set_value(const uint8_t& value) {
      *$self = value;
  }
}
%ignore eprosima::test::CompleteTestType::uint8_opt_field(eprosima::fastcdr::optional<uint8_t>&&);
#endif

// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::uint8_opt_field();
%rename("%s") eprosima::test::CompleteTestType::uint8_opt_field() const;



#if FASTCDR_VERSION_MAJOR == 1
%ignore eprosima::test::CompleteTestType::int16_opt_field(int16_t&&);
#else
%ignore eprosima::fastcdr::optional::value;
%ignore eprosima::fastcdr::optional::reset;
%template(int16_tOpt) eprosima::fastcdr::optional<int16_t>;
%extend eprosima::fastcdr::optional<int16_t> {
  int16_t get_value() const {
      return $self->value();
  }

  void set_value(const int16_t& value) {
      *$self = value;
  }
}
%ignore eprosima::test::CompleteTestType::int16_opt_field(eprosima::fastcdr::optional<int16_t>&&);
#endif

// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::int16_opt_field();
%rename("%s") eprosima::test::CompleteTestType::int16_opt_field() const;



#if FASTCDR_VERSION_MAJOR == 1
%ignore eprosima::test::CompleteTestType::uint16_opt_field(uint16_t&&);
#else
%ignore eprosima::fastcdr::optional::value;
%ignore eprosima::fastcdr::optional::reset;
%template(uint16_tOpt) eprosima::fastcdr::optional<uint16_t>;
%extend eprosima::fastcdr::optional<uint16_t> {
  uint16_t get_value() const {
      return $self->value();
  }

  void set_value(const uint16_t& value) {
      *$self = value;
  }
}
%ignore eprosima::test::CompleteTestType::uint16_opt_field(eprosima::fastcdr::optional<uint16_t>&&);
#endif

// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::uint16_opt_field();
%rename("%s") eprosima::test::CompleteTestType::uint16_opt_field() const;



#if FASTCDR_VERSION_MAJOR == 1
%ignore eprosima::test::CompleteTestType::int32_opt_field(int32_t&&);
#else
%ignore eprosima::fastcdr::optional::value;
%ignore eprosima::fastcdr::optional::reset;
%template(int32_tOpt) eprosima::fastcdr::optional<int32_t>;
%extend eprosima::fastcdr::optional<int32_t> {
  int32_t get_value() const {
      return $self->value();
  }

  void set_value(const int32_t& value) {
      *$self = value;
  }
}
%ignore eprosima::test::CompleteTestType::int32_opt_field(eprosima::fastcdr::optional<int32_t>&&);
#endif

// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::int32_opt_field();
%rename("%s") eprosima::test::CompleteTestType::int32_opt_field() const;



#if FASTCDR_VERSION_MAJOR == 1
%ignore eprosima::test::CompleteTestType::uint32_opt_field(uint32_t&&);
#else
%ignore eprosima::fastcdr::optional::value;
%ignore eprosima::fastcdr::optional::reset;
%template(uint32_tOpt) eprosima::fastcdr::optional<uint32_t>;
%extend eprosima::fastcdr::optional<uint32_t> {
  uint32_t get_value() const {
      return $self->value();
  }

  void set_value(const uint32_t& value) {
      *$self = value;
  }
}
%ignore eprosima::test::CompleteTestType::uint32_opt_field(eprosima::fastcdr::optional<uint32_t>&&);
#endif

// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::uint32_opt_field();
%rename("%s") eprosima::test::CompleteTestType::uint32_opt_field() const;



#if FASTCDR_VERSION_MAJOR == 1
%ignore eprosima::test::CompleteTestType::int64_opt_field(int64_t&&);
#else
%ignore eprosima::fastcdr::optional::value;
%ignore eprosima::fastcdr::optional::reset;
%template(int64_tOpt) eprosima::fastcdr::optional<int64_t>;
%extend eprosima::fastcdr::optional<int64_t> {
  int64_t get_value() const {
      return $self->value();
  }

  void set_value(const int64_t& value) {
      *$self = value;
  }
}
%ignore eprosima::test::CompleteTestType::int64_opt_field(eprosima::fastcdr::optional<int64_t>&&);
#endif

// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::int64_opt_field();
%rename("%s") eprosima::test::CompleteTestType::int64_opt_field() const;



#if FASTCDR_VERSION_MAJOR == 1
%ignore eprosima::test::CompleteTestType::uint64_opt_field(uint64_t&&);
#else
%ignore eprosima::fastcdr::optional::value;
%ignore eprosima::fastcdr::optional::reset;
%template(uint64_tOpt) eprosima::fastcdr::optional<uint64_t>;
%extend eprosima::fastcdr::optional<uint64_t> {
  uint64_t get_value() const {
      return $self->value();
  }

  void set_value(const uint64_t& value) {
      *$self = value;
  }
}
%ignore eprosima::test::CompleteTestType::uint64_opt_field(eprosima::fastcdr::optional<uint64_t>&&);
#endif

// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::uint64_opt_field();
%rename("%s") eprosima::test::CompleteTestType::uint64_opt_field() const;



#if FASTCDR_VERSION_MAJOR == 1
%ignore eprosima::test::CompleteTestType::float_opt_field(float&&);
#else
%ignore eprosima::fastcdr::optional::value;
%ignore eprosima::fastcdr::optional::reset;
%template(floatOpt) eprosima::fastcdr::optional<float>;
%extend eprosima::fastcdr::optional<float> {
  float get_value() const {
      return $self->value();
  }

  void set_value(const float& value) {
      *$self = value;
  }
}
%ignore eprosima::test::CompleteTestType::float_opt_field(eprosima::fastcdr::optional<float>&&);
#endif

// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::float_opt_field();
%rename("%s") eprosima::test::CompleteTestType::float_opt_field() const;



#if FASTCDR_VERSION_MAJOR == 1
%ignore eprosima::test::CompleteTestType::double_opt_field(double&&);
#else
%ignore eprosima::fastcdr::optional::value;
%ignore eprosima::fastcdr::optional::reset;
%template(doubleOpt) eprosima::fastcdr::optional<double>;
%extend eprosima::fastcdr::optional<double> {
  double get_value() const {
      return $self->value();
  }

  void set_value(const double& value) {
      *$self = value;
  }
}
%ignore eprosima::test::CompleteTestType::double_opt_field(eprosima::fastcdr::optional<double>&&);
#endif

// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::double_opt_field();
%rename("%s") eprosima::test::CompleteTestType::double_opt_field() const;



#if FASTCDR_VERSION_MAJOR == 1
%ignore eprosima::test::CompleteTestType::bool_opt_field(bool&&);
#else
%ignore eprosima::fastcdr::optional::value;
%ignore eprosima::fastcdr::optional::reset;
%template(boolOpt) eprosima::fastcdr::optional<bool>;
%extend eprosima::fastcdr::optional<bool> {
  bool get_value() const {
      return $self->value();
  }

  void set_value(const bool& value) {
      *$self = value;
  }
}
%ignore eprosima::test::CompleteTestType::bool_opt_field(eprosima::fastcdr::optional<bool>&&);
#endif

// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::bool_opt_field();
%rename("%s") eprosima::test::CompleteTestType::bool_opt_field() const;



#if FASTCDR_VERSION_MAJOR == 1
%ignore eprosima::test::CompleteTestType::string_opt_field(std::string&&);
#else
%ignore eprosima::fastcdr::optional::value;
%ignore eprosima::fastcdr::optional::reset;
%template(stringOpt) eprosima::fastcdr::optional<std::string>;
%extend eprosima::fastcdr::optional<std::string> {
  std::string get_value() const {
      return $self->value();
  }

  void set_value(const std::string& value) {
      *$self = value;
  }
}
%ignore eprosima::test::CompleteTestType::string_opt_field(eprosima::fastcdr::optional<std::string>&&);
#endif

// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::string_opt_field();
%rename("%s") eprosima::test::CompleteTestType::string_opt_field() const;



#if FASTCDR_VERSION_MAJOR == 1
%ignore eprosima::test::CompleteTestType::enum_opt_field(eprosima::test::Color&&);
#else
%ignore eprosima::fastcdr::optional::value;
%ignore eprosima::fastcdr::optional::reset;
%template(ColorOpt) eprosima::fastcdr::optional<eprosima::test::Color>;
%extend eprosima::fastcdr::optional<eprosima::test::Color> {
  eprosima::test::Color get_value() const {
      return $self->value();
  }

  void set_value(const eprosima::test::Color& value) {
      *$self = value;
  }
}
%ignore eprosima::test::CompleteTestType::enum_opt_field(eprosima::fastcdr::optional<eprosima::test::Color>&&);
#endif

// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::enum_opt_field();
%rename("%s") eprosima::test::CompleteTestType::enum_opt_field() const;



#if FASTCDR_VERSION_MAJOR == 1
%ignore eprosima::test::CompleteTestType::enum2_opt_field(eprosima::test::Material&&);
#else
%ignore eprosima::fastcdr::optional::value;
%ignore eprosima::fastcdr::optional::reset;
%template(MaterialOpt) eprosima::fastcdr::optional<eprosima::test::Material>;
%extend eprosima::fastcdr::optional<eprosima::test::Material> {
  eprosima::test::Material get_value() const {
      return $self->value();
  }

  void set_value(const eprosima::test::Material& value) {
      *$self = value;
  }
}
%ignore eprosima::test::CompleteTestType::enum2_opt_field(eprosima::fastcdr::optional<eprosima::test::Material>&&);
#endif

// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::enum2_opt_field();
%rename("%s") eprosima::test::CompleteTestType::enum2_opt_field() const;



#if FASTCDR_VERSION_MAJOR == 1
%ignore eprosima::test::CompleteTestType::struct_opt_field(eprosima::test::StructType&&);
#else
%ignore eprosima::fastcdr::optional::value;
%ignore eprosima::fastcdr::optional::reset;
%template(StructTypeOpt) eprosima::fastcdr::optional<eprosima::test::StructType>;
%extend eprosima::fastcdr::optional<eprosima::test::StructType> {
  eprosima::test::StructType get_value() const {
      return $self->value();
  }

  void set_value(const eprosima::test::StructType& value) {
      *$self = value;
  }
}
%ignore eprosima::test::CompleteTestType::struct_opt_field(eprosima::fastcdr::optional<eprosima::test::StructType>&&);
#endif

// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::struct_opt_field();
%rename("%s") eprosima::test::CompleteTestType::struct_opt_field() const;



%ignore eprosima::test::CompleteTestType::array_char_field(std::array<char, max_array_size>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::array_char_field() const;
%template(char_3_array) std::array<char,3>;
%extend std::array<char, 3>
{
    const char* get_buffer() const
    {
        return self->data();
    }
}


%ignore eprosima::test::CompleteTestType::array_uint8_field(std::array<uint8_t, max_array_size>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::array_uint8_field() const;
%template(uint8_t_3_array) std::array<uint8_t,3>;
%extend std::array<uint8_t, 3>
{
    const uint8_t* get_buffer() const
    {
        return self->data();
    }
}


%ignore eprosima::test::CompleteTestType::array_int16_field(std::array<int16_t, max_array_size>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::array_int16_field() const;
%template(int16_t_3_array) std::array<int16_t,3>;
%extend std::array<int16_t, 3>
{
    const int16_t* get_buffer() const
    {
        return self->data();
    }
}


%ignore eprosima::test::CompleteTestType::array_uint16_field(std::array<uint16_t, max_array_size>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::array_uint16_field() const;
%template(uint16_t_3_array) std::array<uint16_t,3>;
%extend std::array<uint16_t, 3>
{
    const uint16_t* get_buffer() const
    {
        return self->data();
    }
}


%ignore eprosima::test::CompleteTestType::array_int32_field(std::array<int32_t, max_array_size>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::array_int32_field() const;
%template(int32_t_3_array) std::array<int32_t,3>;
%extend std::array<int32_t, 3>
{
    const int32_t* get_buffer() const
    {
        return self->data();
    }
}


%ignore eprosima::test::CompleteTestType::array_uint32_field(std::array<uint32_t, max_array_size>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::array_uint32_field() const;
%template(uint32_t_3_array) std::array<uint32_t,3>;
%extend std::array<uint32_t, 3>
{
    const uint32_t* get_buffer() const
    {
        return self->data();
    }
}


%ignore eprosima::test::CompleteTestType::array_int64_field(std::array<int64_t, max_array_size>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::array_int64_field() const;
%template(int64_t_3_array) std::array<int64_t,3>;
%extend std::array<int64_t, 3>
{
    const int64_t* get_buffer() const
    {
        return self->data();
    }
}


%ignore eprosima::test::CompleteTestType::array_uint64_field(std::array<uint64_t, max_array_size>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::array_uint64_field() const;
%template(uint64_t_3_array) std::array<uint64_t,3>;
%extend std::array<uint64_t, 3>
{
    const uint64_t* get_buffer() const
    {
        return self->data();
    }
}


%ignore eprosima::test::CompleteTestType::array_float_field(std::array<float, max_array_size>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::array_float_field() const;
%template(float_3_array) std::array<float,3>;
%extend std::array<float, 3>
{
    const float* get_buffer() const
    {
        return self->data();
    }
}


%ignore eprosima::test::CompleteTestType::array_double_field(std::array<double, max_array_size>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::array_double_field() const;
%template(double_3_array) std::array<double,3>;
%extend std::array<double, 3>
{
    const double* get_buffer() const
    {
        return self->data();
    }
}


%ignore eprosima::test::CompleteTestType::array_bool_field(std::array<bool, max_array_size>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::array_bool_field() const;
%template(bool_3_array) std::array<bool,3>;
%extend std::array<bool, 3>
{
    const bool* get_buffer() const
    {
        return self->data();
    }
}


%ignore eprosima::test::CompleteTestType::array_enum_field(std::array<eprosima::test::Color, max_array_size>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::array_enum_field() const;
%template(Color_3_array) std::array<enum eprosima::test::Color,3>;
%extend std::array<enum eprosima::test::Color, 3>
{
    const enum eprosima::test::Color* get_buffer() const
    {
        return self->data();
    }
}


%ignore eprosima::test::CompleteTestType::array_enum2_field(std::array<eprosima::test::Material, max_array_size>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::array_enum2_field() const;
%template(Material_3_array) std::array<enum eprosima::test::Material,3>;
%extend std::array<enum eprosima::test::Material, 3>
{
    const enum eprosima::test::Material* get_buffer() const
    {
        return self->data();
    }
}


%ignore eprosima::test::CompleteTestType::array_struct_field(std::array<eprosima::test::StructType, max_array_size>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::array_struct_field() const;
%template(StructType_3_array) std::array<eprosima::test::StructType,3>;


%ignore eprosima::test::CompleteTestType::bounded_sequence_char_field(std::vector<char>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::bounded_sequence_char_field() const;
%extend std::vector<char>
{
    const char* get_buffer() const
    {
        return self->data();
    }
}

%template(char_vector) std::vector<char>;


%ignore eprosima::test::CompleteTestType::bounded_sequence_uint8_field(std::vector<uint8_t>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::bounded_sequence_uint8_field() const;
%extend std::vector<uint8_t>
{
    const uint8_t* get_buffer() const
    {
        return self->data();
    }
}

%template(uint8_t_vector) std::vector<uint8_t>;


%ignore eprosima::test::CompleteTestType::bounded_sequence_int16_field(std::vector<int16_t>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::bounded_sequence_int16_field() const;
%extend std::vector<int16_t>
{
    const int16_t* get_buffer() const
    {
        return self->data();
    }
}

%template(int16_t_vector) std::vector<int16_t>;


%ignore eprosima::test::CompleteTestType::bounded_sequence_uint16_field(std::vector<uint16_t>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::bounded_sequence_uint16_field() const;
%extend std::vector<uint16_t>
{
    const uint16_t* get_buffer() const
    {
        return self->data();
    }
}

%template(uint16_t_vector) std::vector<uint16_t>;


%ignore eprosima::test::CompleteTestType::bounded_sequence_int32_field(std::vector<int32_t>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::bounded_sequence_int32_field() const;
%extend std::vector<int32_t>
{
    const int32_t* get_buffer() const
    {
        return self->data();
    }
}

%template(int32_t_vector) std::vector<int32_t>;


%ignore eprosima::test::CompleteTestType::bounded_sequence_uint32_field(std::vector<uint32_t>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::bounded_sequence_uint32_field() const;
%extend std::vector<uint32_t>
{
    const uint32_t* get_buffer() const
    {
        return self->data();
    }
}

%template(uint32_t_vector) std::vector<uint32_t>;


%ignore eprosima::test::CompleteTestType::bounded_sequence_int64_field(std::vector<int64_t>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::bounded_sequence_int64_field() const;
%extend std::vector<int64_t>
{
    const int64_t* get_buffer() const
    {
        return self->data();
    }
}

%template(int64_t_vector) std::vector<int64_t>;


%ignore eprosima::test::CompleteTestType::bounded_sequence_uint64_field(std::vector<uint64_t>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::bounded_sequence_uint64_field() const;
%extend std::vector<uint64_t>
{
    const uint64_t* get_buffer() const
    {
        return self->data();
    }
}

%template(uint64_t_vector) std::vector<uint64_t>;


%ignore eprosima::test::CompleteTestType::bounded_sequence_float_field(std::vector<float>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::bounded_sequence_float_field() const;
%extend std::vector<float>
{
    const float* get_buffer() const
    {
        return self->data();
    }
}

%template(float_vector) std::vector<float>;


%ignore eprosima::test::CompleteTestType::bounded_sequence_double_field(std::vector<double>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::bounded_sequence_double_field() const;
%extend std::vector<double>
{
    const double* get_buffer() const
    {
        return self->data();
    }
}

%template(double_vector) std::vector<double>;


%ignore eprosima::test::CompleteTestType::bounded_sequence_bool_field(std::vector<bool>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::bounded_sequence_bool_field() const;
%template(bool_vector) std::vector<bool>;


%ignore eprosima::test::CompleteTestType::bounded_sequence_enum_field(std::vector<eprosima::test::Color>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::bounded_sequence_enum_field() const;
%extend std::vector<eprosima::test::Color>
{
    const eprosima::test::Color* get_buffer() const
    {
        return self->data();
    }
}

%template(Color_vector) std::vector<enum eprosima::test::Color>;


%ignore eprosima::test::CompleteTestType::bounded_sequence_enum2_field(std::vector<eprosima::test::Material>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::bounded_sequence_enum2_field() const;
%extend std::vector<eprosima::test::Material>
{
    const eprosima::test::Material* get_buffer() const
    {
        return self->data();
    }
}

%template(Material_vector) std::vector<enum eprosima::test::Material>;


%ignore eprosima::test::CompleteTestType::bounded_sequence_struct_field(std::vector<eprosima::test::StructType>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::bounded_sequence_struct_field() const;
%template(StructType_vector) std::vector<eprosima::test::StructType>;


%ignore eprosima::test::CompleteTestType::unbounded_sequence_char_field(std::vector<char>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::unbounded_sequence_char_field() const;
%extend std::vector<char>
{
    const char* get_buffer() const
    {
        return self->data();
    }
}

%template(char_vector) std::vector<char>;


%ignore eprosima::test::CompleteTestType::unbounded_sequence_uint8_field(std::vector<uint8_t>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::unbounded_sequence_uint8_field() const;
%extend std::vector<uint8_t>
{
    const uint8_t* get_buffer() const
    {
        return self->data();
    }
}

%template(uint8_t_vector) std::vector<uint8_t>;


%ignore eprosima::test::CompleteTestType::unbounded_sequence_int16_field(std::vector<int16_t>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::unbounded_sequence_int16_field() const;
%extend std::vector<int16_t>
{
    const int16_t* get_buffer() const
    {
        return self->data();
    }
}

%template(int16_t_vector) std::vector<int16_t>;


%ignore eprosima::test::CompleteTestType::unbounded_sequence_uint16_field(std::vector<uint16_t>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::unbounded_sequence_uint16_field() const;
%extend std::vector<uint16_t>
{
    const uint16_t* get_buffer() const
    {
        return self->data();
    }
}

%template(uint16_t_vector) std::vector<uint16_t>;


%ignore eprosima::test::CompleteTestType::unbounded_sequence_int32_field(std::vector<int32_t>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::unbounded_sequence_int32_field() const;
%extend std::vector<int32_t>
{
    const int32_t* get_buffer() const
    {
        return self->data();
    }
}

%template(int32_t_vector) std::vector<int32_t>;


%ignore eprosima::test::CompleteTestType::unbounded_sequence_uint32_field(std::vector<uint32_t>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::unbounded_sequence_uint32_field() const;
%extend std::vector<uint32_t>
{
    const uint32_t* get_buffer() const
    {
        return self->data();
    }
}

%template(uint32_t_vector) std::vector<uint32_t>;


%ignore eprosima::test::CompleteTestType::unbounded_sequence_int64_field(std::vector<int64_t>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::unbounded_sequence_int64_field() const;
%extend std::vector<int64_t>
{
    const int64_t* get_buffer() const
    {
        return self->data();
    }
}

%template(int64_t_vector) std::vector<int64_t>;


%ignore eprosima::test::CompleteTestType::unbounded_sequence_uint64_field(std::vector<uint64_t>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::unbounded_sequence_uint64_field() const;
%extend std::vector<uint64_t>
{
    const uint64_t* get_buffer() const
    {
        return self->data();
    }
}

%template(uint64_t_vector) std::vector<uint64_t>;


%ignore eprosima::test::CompleteTestType::unbounded_sequence_float_field(std::vector<float>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::unbounded_sequence_float_field() const;
%extend std::vector<float>
{
    const float* get_buffer() const
    {
        return self->data();
    }
}

%template(float_vector) std::vector<float>;


%ignore eprosima::test::CompleteTestType::unbounded_sequence_double_field(std::vector<double>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::unbounded_sequence_double_field() const;
%extend std::vector<double>
{
    const double* get_buffer() const
    {
        return self->data();
    }
}

%template(double_vector) std::vector<double>;


%ignore eprosima::test::CompleteTestType::unbounded_sequence_bool_field(std::vector<bool>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::unbounded_sequence_bool_field() const;
%template(bool_vector) std::vector<bool>;


%ignore eprosima::test::CompleteTestType::unbounded_sequence_enum_field(std::vector<eprosima::test::Color>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::unbounded_sequence_enum_field() const;
%extend std::vector<eprosima::test::Color>
{
    const eprosima::test::Color* get_buffer() const
    {
        return self->data();
    }
}

%template(Color_vector) std::vector<enum eprosima::test::Color>;


%ignore eprosima::test::CompleteTestType::unbounded_sequence_enum2_field(std::vector<eprosima::test::Material>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::unbounded_sequence_enum2_field() const;
%extend std::vector<eprosima::test::Material>
{
    const eprosima::test::Material* get_buffer() const
    {
        return self->data();
    }
}

%template(Material_vector) std::vector<enum eprosima::test::Material>;


%ignore eprosima::test::CompleteTestType::unbounded_sequence_struct_field(std::vector<eprosima::test::StructType>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::CompleteTestType::unbounded_sequence_struct_field() const;
%template(StructType_vector) std::vector<eprosima::test::StructType>;


%template(_CompleteTestTypeSeq) eprosima::fastdds::dds::LoanableTypedCollection<eprosima::test::CompleteTestType, std::false_type>;
%template(CompleteTestTypeSeq) eprosima::fastdds::dds::LoanableSequence<eprosima::test::CompleteTestType, std::false_type>;
%extend eprosima::fastdds::dds::LoanableSequence<eprosima::test::CompleteTestType, std::false_type>
{
    size_t __len__() const
    {
        return self->length();
    }

    const eprosima::test::CompleteTestType& __getitem__(size_t i) const
    {
        return (*self)[i];
    }
}





////////////////////////////////////////////////////////
// Binding for class eprosima::test::KeyedCompleteTestType
////////////////////////////////////////////////////////

// Ignore overloaded methods that have no application on Python
// Otherwise they will issue a warning
%ignore eprosima::test::KeyedCompleteTestType::KeyedCompleteTestType(eprosima::test::KeyedCompleteTestType&&);

// Overloaded getter methods shadow each other and are equivalent in python
// Avoid a warning ignoring all but one
%ignore eprosima::test::KeyedCompleteTestType::id(int32_t&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::id();
%rename("%s") eprosima::test::KeyedCompleteTestType::id() const;



%ignore eprosima::test::KeyedCompleteTestType::char_field(char&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::char_field();
%rename("%s") eprosima::test::KeyedCompleteTestType::char_field() const;



%ignore eprosima::test::KeyedCompleteTestType::uint8_field(uint8_t&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::uint8_field();
%rename("%s") eprosima::test::KeyedCompleteTestType::uint8_field() const;



%ignore eprosima::test::KeyedCompleteTestType::int16_field(int16_t&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::int16_field();
%rename("%s") eprosima::test::KeyedCompleteTestType::int16_field() const;



%ignore eprosima::test::KeyedCompleteTestType::uint16_field(uint16_t&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::uint16_field();
%rename("%s") eprosima::test::KeyedCompleteTestType::uint16_field() const;



%ignore eprosima::test::KeyedCompleteTestType::int32_field(int32_t&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::int32_field();
%rename("%s") eprosima::test::KeyedCompleteTestType::int32_field() const;



%ignore eprosima::test::KeyedCompleteTestType::uint32_field(uint32_t&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::uint32_field();
%rename("%s") eprosima::test::KeyedCompleteTestType::uint32_field() const;



%ignore eprosima::test::KeyedCompleteTestType::int64_field(int64_t&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::int64_field();
%rename("%s") eprosima::test::KeyedCompleteTestType::int64_field() const;



%ignore eprosima::test::KeyedCompleteTestType::uint64_field(uint64_t&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::uint64_field();
%rename("%s") eprosima::test::KeyedCompleteTestType::uint64_field() const;



%ignore eprosima::test::KeyedCompleteTestType::float_field(float&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::float_field();
%rename("%s") eprosima::test::KeyedCompleteTestType::float_field() const;



%ignore eprosima::test::KeyedCompleteTestType::double_field(double&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::double_field();
%rename("%s") eprosima::test::KeyedCompleteTestType::double_field() const;



%ignore eprosima::test::KeyedCompleteTestType::bool_field(bool&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::bool_field();
%rename("%s") eprosima::test::KeyedCompleteTestType::bool_field() const;



%ignore eprosima::test::KeyedCompleteTestType::string_field(std::string&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::string_field();
%rename("%s") eprosima::test::KeyedCompleteTestType::string_field() const;



%ignore eprosima::test::KeyedCompleteTestType::enum_field(eprosima::test::Color&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::enum_field();
%rename("%s") eprosima::test::KeyedCompleteTestType::enum_field() const;



%ignore eprosima::test::KeyedCompleteTestType::enum2_field(eprosima::test::Material&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::enum2_field();
%rename("%s") eprosima::test::KeyedCompleteTestType::enum2_field() const;



%ignore eprosima::test::KeyedCompleteTestType::struct_field(eprosima::test::StructType&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::struct_field();
%rename("%s") eprosima::test::KeyedCompleteTestType::struct_field() const;



#if FASTCDR_VERSION_MAJOR == 1
%ignore eprosima::test::KeyedCompleteTestType::char_opt_field(char&&);
#else
%ignore eprosima::fastcdr::optional::value;
%ignore eprosima::fastcdr::optional::reset;
%template(charOpt) eprosima::fastcdr::optional<char>;
%extend eprosima::fastcdr::optional<char> {
  char get_value() const {
      return $self->value();
  }

  void set_value(const char& value) {
      *$self = value;
  }
}
%ignore eprosima::test::KeyedCompleteTestType::char_opt_field(eprosima::fastcdr::optional<char>&&);
#endif

// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::char_opt_field();
%rename("%s") eprosima::test::KeyedCompleteTestType::char_opt_field() const;



#if FASTCDR_VERSION_MAJOR == 1
%ignore eprosima::test::KeyedCompleteTestType::uint8_opt_field(uint8_t&&);
#else
%ignore eprosima::fastcdr::optional::value;
%ignore eprosima::fastcdr::optional::reset;
%template(uint8_tOpt) eprosima::fastcdr::optional<uint8_t>;
%extend eprosima::fastcdr::optional<uint8_t> {
  uint8_t get_value() const {
      return $self->value();
  }

  void set_value(const uint8_t& value) {
      *$self = value;
  }
}
%ignore eprosima::test::KeyedCompleteTestType::uint8_opt_field(eprosima::fastcdr::optional<uint8_t>&&);
#endif

// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::uint8_opt_field();
%rename("%s") eprosima::test::KeyedCompleteTestType::uint8_opt_field() const;



#if FASTCDR_VERSION_MAJOR == 1
%ignore eprosima::test::KeyedCompleteTestType::int16_opt_field(int16_t&&);
#else
%ignore eprosima::fastcdr::optional::value;
%ignore eprosima::fastcdr::optional::reset;
%template(int16_tOpt) eprosima::fastcdr::optional<int16_t>;
%extend eprosima::fastcdr::optional<int16_t> {
  int16_t get_value() const {
      return $self->value();
  }

  void set_value(const int16_t& value) {
      *$self = value;
  }
}
%ignore eprosima::test::KeyedCompleteTestType::int16_opt_field(eprosima::fastcdr::optional<int16_t>&&);
#endif

// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::int16_opt_field();
%rename("%s") eprosima::test::KeyedCompleteTestType::int16_opt_field() const;



#if FASTCDR_VERSION_MAJOR == 1
%ignore eprosima::test::KeyedCompleteTestType::uint16_opt_field(uint16_t&&);
#else
%ignore eprosima::fastcdr::optional::value;
%ignore eprosima::fastcdr::optional::reset;
%template(uint16_tOpt) eprosima::fastcdr::optional<uint16_t>;
%extend eprosima::fastcdr::optional<uint16_t> {
  uint16_t get_value() const {
      return $self->value();
  }

  void set_value(const uint16_t& value) {
      *$self = value;
  }
}
%ignore eprosima::test::KeyedCompleteTestType::uint16_opt_field(eprosima::fastcdr::optional<uint16_t>&&);
#endif

// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::uint16_opt_field();
%rename("%s") eprosima::test::KeyedCompleteTestType::uint16_opt_field() const;



#if FASTCDR_VERSION_MAJOR == 1
%ignore eprosima::test::KeyedCompleteTestType::int32_opt_field(int32_t&&);
#else
%ignore eprosima::fastcdr::optional::value;
%ignore eprosima::fastcdr::optional::reset;
%template(int32_tOpt) eprosima::fastcdr::optional<int32_t>;
%extend eprosima::fastcdr::optional<int32_t> {
  int32_t get_value() const {
      return $self->value();
  }

  void set_value(const int32_t& value) {
      *$self = value;
  }
}
%ignore eprosima::test::KeyedCompleteTestType::int32_opt_field(eprosima::fastcdr::optional<int32_t>&&);
#endif

// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::int32_opt_field();
%rename("%s") eprosima::test::KeyedCompleteTestType::int32_opt_field() const;



#if FASTCDR_VERSION_MAJOR == 1
%ignore eprosima::test::KeyedCompleteTestType::uint32_opt_field(uint32_t&&);
#else
%ignore eprosima::fastcdr::optional::value;
%ignore eprosima::fastcdr::optional::reset;
%template(uint32_tOpt) eprosima::fastcdr::optional<uint32_t>;
%extend eprosima::fastcdr::optional<uint32_t> {
  uint32_t get_value() const {
      return $self->value();
  }

  void set_value(const uint32_t& value) {
      *$self = value;
  }
}
%ignore eprosima::test::KeyedCompleteTestType::uint32_opt_field(eprosima::fastcdr::optional<uint32_t>&&);
#endif

// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::uint32_opt_field();
%rename("%s") eprosima::test::KeyedCompleteTestType::uint32_opt_field() const;



#if FASTCDR_VERSION_MAJOR == 1
%ignore eprosima::test::KeyedCompleteTestType::int64_opt_field(int64_t&&);
#else
%ignore eprosima::fastcdr::optional::value;
%ignore eprosima::fastcdr::optional::reset;
%template(int64_tOpt) eprosima::fastcdr::optional<int64_t>;
%extend eprosima::fastcdr::optional<int64_t> {
  int64_t get_value() const {
      return $self->value();
  }

  void set_value(const int64_t& value) {
      *$self = value;
  }
}
%ignore eprosima::test::KeyedCompleteTestType::int64_opt_field(eprosima::fastcdr::optional<int64_t>&&);
#endif

// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::int64_opt_field();
%rename("%s") eprosima::test::KeyedCompleteTestType::int64_opt_field() const;



#if FASTCDR_VERSION_MAJOR == 1
%ignore eprosima::test::KeyedCompleteTestType::uint64_opt_field(uint64_t&&);
#else
%ignore eprosima::fastcdr::optional::value;
%ignore eprosima::fastcdr::optional::reset;
%template(uint64_tOpt) eprosima::fastcdr::optional<uint64_t>;
%extend eprosima::fastcdr::optional<uint64_t> {
  uint64_t get_value() const {
      return $self->value();
  }

  void set_value(const uint64_t& value) {
      *$self = value;
  }
}
%ignore eprosima::test::KeyedCompleteTestType::uint64_opt_field(eprosima::fastcdr::optional<uint64_t>&&);
#endif

// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::uint64_opt_field();
%rename("%s") eprosima::test::KeyedCompleteTestType::uint64_opt_field() const;



#if FASTCDR_VERSION_MAJOR == 1
%ignore eprosima::test::KeyedCompleteTestType::float_opt_field(float&&);
#else
%ignore eprosima::fastcdr::optional::value;
%ignore eprosima::fastcdr::optional::reset;
%template(floatOpt) eprosima::fastcdr::optional<float>;
%extend eprosima::fastcdr::optional<float> {
  float get_value() const {
      return $self->value();
  }

  void set_value(const float& value) {
      *$self = value;
  }
}
%ignore eprosima::test::KeyedCompleteTestType::float_opt_field(eprosima::fastcdr::optional<float>&&);
#endif

// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::float_opt_field();
%rename("%s") eprosima::test::KeyedCompleteTestType::float_opt_field() const;



#if FASTCDR_VERSION_MAJOR == 1
%ignore eprosima::test::KeyedCompleteTestType::double_opt_field(double&&);
#else
%ignore eprosima::fastcdr::optional::value;
%ignore eprosima::fastcdr::optional::reset;
%template(doubleOpt) eprosima::fastcdr::optional<double>;
%extend eprosima::fastcdr::optional<double> {
  double get_value() const {
      return $self->value();
  }

  void set_value(const double& value) {
      *$self = value;
  }
}
%ignore eprosima::test::KeyedCompleteTestType::double_opt_field(eprosima::fastcdr::optional<double>&&);
#endif

// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::double_opt_field();
%rename("%s") eprosima::test::KeyedCompleteTestType::double_opt_field() const;



#if FASTCDR_VERSION_MAJOR == 1
%ignore eprosima::test::KeyedCompleteTestType::bool_opt_field(bool&&);
#else
%ignore eprosima::fastcdr::optional::value;
%ignore eprosima::fastcdr::optional::reset;
%template(boolOpt) eprosima::fastcdr::optional<bool>;
%extend eprosima::fastcdr::optional<bool> {
  bool get_value() const {
      return $self->value();
  }

  void set_value(const bool& value) {
      *$self = value;
  }
}
%ignore eprosima::test::KeyedCompleteTestType::bool_opt_field(eprosima::fastcdr::optional<bool>&&);
#endif

// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::bool_opt_field();
%rename("%s") eprosima::test::KeyedCompleteTestType::bool_opt_field() const;



#if FASTCDR_VERSION_MAJOR == 1
%ignore eprosima::test::KeyedCompleteTestType::string_opt_field(std::string&&);
#else
%ignore eprosima::fastcdr::optional::value;
%ignore eprosima::fastcdr::optional::reset;
%template(stringOpt) eprosima::fastcdr::optional<std::string>;
%extend eprosima::fastcdr::optional<std::string> {
  std::string get_value() const {
      return $self->value();
  }

  void set_value(const std::string& value) {
      *$self = value;
  }
}
%ignore eprosima::test::KeyedCompleteTestType::string_opt_field(eprosima::fastcdr::optional<std::string>&&);
#endif

// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::string_opt_field();
%rename("%s") eprosima::test::KeyedCompleteTestType::string_opt_field() const;



#if FASTCDR_VERSION_MAJOR == 1
%ignore eprosima::test::KeyedCompleteTestType::enum_opt_field(eprosima::test::Color&&);
#else
%ignore eprosima::fastcdr::optional::value;
%ignore eprosima::fastcdr::optional::reset;
%template(ColorOpt) eprosima::fastcdr::optional<eprosima::test::Color>;
%extend eprosima::fastcdr::optional<eprosima::test::Color> {
  eprosima::test::Color get_value() const {
      return $self->value();
  }

  void set_value(const eprosima::test::Color& value) {
      *$self = value;
  }
}
%ignore eprosima::test::KeyedCompleteTestType::enum_opt_field(eprosima::fastcdr::optional<eprosima::test::Color>&&);
#endif

// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::enum_opt_field();
%rename("%s") eprosima::test::KeyedCompleteTestType::enum_opt_field() const;



#if FASTCDR_VERSION_MAJOR == 1
%ignore eprosima::test::KeyedCompleteTestType::enum2_opt_field(eprosima::test::Material&&);
#else
%ignore eprosima::fastcdr::optional::value;
%ignore eprosima::fastcdr::optional::reset;
%template(MaterialOpt) eprosima::fastcdr::optional<eprosima::test::Material>;
%extend eprosima::fastcdr::optional<eprosima::test::Material> {
  eprosima::test::Material get_value() const {
      return $self->value();
  }

  void set_value(const eprosima::test::Material& value) {
      *$self = value;
  }
}
%ignore eprosima::test::KeyedCompleteTestType::enum2_opt_field(eprosima::fastcdr::optional<eprosima::test::Material>&&);
#endif

// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::enum2_opt_field();
%rename("%s") eprosima::test::KeyedCompleteTestType::enum2_opt_field() const;



#if FASTCDR_VERSION_MAJOR == 1
%ignore eprosima::test::KeyedCompleteTestType::struct_opt_field(eprosima::test::StructType&&);
#else
%ignore eprosima::fastcdr::optional::value;
%ignore eprosima::fastcdr::optional::reset;
%template(StructTypeOpt) eprosima::fastcdr::optional<eprosima::test::StructType>;
%extend eprosima::fastcdr::optional<eprosima::test::StructType> {
  eprosima::test::StructType get_value() const {
      return $self->value();
  }

  void set_value(const eprosima::test::StructType& value) {
      *$self = value;
  }
}
%ignore eprosima::test::KeyedCompleteTestType::struct_opt_field(eprosima::fastcdr::optional<eprosima::test::StructType>&&);
#endif

// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::struct_opt_field();
%rename("%s") eprosima::test::KeyedCompleteTestType::struct_opt_field() const;



%ignore eprosima::test::KeyedCompleteTestType::array_char_field(std::array<char, max_array_size>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::array_char_field() const;
%template(char_3_array) std::array<char,3>;
%extend std::array<char, 3>
{
    const char* get_buffer() const
    {
        return self->data();
    }
}


%ignore eprosima::test::KeyedCompleteTestType::array_uint8_field(std::array<uint8_t, max_array_size>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::array_uint8_field() const;
%template(uint8_t_3_array) std::array<uint8_t,3>;
%extend std::array<uint8_t, 3>
{
    const uint8_t* get_buffer() const
    {
        return self->data();
    }
}


%ignore eprosima::test::KeyedCompleteTestType::array_int16_field(std::array<int16_t, max_array_size>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::array_int16_field() const;
%template(int16_t_3_array) std::array<int16_t,3>;
%extend std::array<int16_t, 3>
{
    const int16_t* get_buffer() const
    {
        return self->data();
    }
}


%ignore eprosima::test::KeyedCompleteTestType::array_uint16_field(std::array<uint16_t, max_array_size>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::array_uint16_field() const;
%template(uint16_t_3_array) std::array<uint16_t,3>;
%extend std::array<uint16_t, 3>
{
    const uint16_t* get_buffer() const
    {
        return self->data();
    }
}


%ignore eprosima::test::KeyedCompleteTestType::array_int32_field(std::array<int32_t, max_array_size>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::array_int32_field() const;
%template(int32_t_3_array) std::array<int32_t,3>;
%extend std::array<int32_t, 3>
{
    const int32_t* get_buffer() const
    {
        return self->data();
    }
}


%ignore eprosima::test::KeyedCompleteTestType::array_uint32_field(std::array<uint32_t, max_array_size>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::array_uint32_field() const;
%template(uint32_t_3_array) std::array<uint32_t,3>;
%extend std::array<uint32_t, 3>
{
    const uint32_t* get_buffer() const
    {
        return self->data();
    }
}


%ignore eprosima::test::KeyedCompleteTestType::array_int64_field(std::array<int64_t, max_array_size>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::array_int64_field() const;
%template(int64_t_3_array) std::array<int64_t,3>;
%extend std::array<int64_t, 3>
{
    const int64_t* get_buffer() const
    {
        return self->data();
    }
}


%ignore eprosima::test::KeyedCompleteTestType::array_uint64_field(std::array<uint64_t, max_array_size>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::array_uint64_field() const;
%template(uint64_t_3_array) std::array<uint64_t,3>;
%extend std::array<uint64_t, 3>
{
    const uint64_t* get_buffer() const
    {
        return self->data();
    }
}


%ignore eprosima::test::KeyedCompleteTestType::array_float_field(std::array<float, max_array_size>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::array_float_field() const;
%template(float_3_array) std::array<float,3>;
%extend std::array<float, 3>
{
    const float* get_buffer() const
    {
        return self->data();
    }
}


%ignore eprosima::test::KeyedCompleteTestType::array_double_field(std::array<double, max_array_size>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::array_double_field() const;
%template(double_3_array) std::array<double,3>;
%extend std::array<double, 3>
{
    const double* get_buffer() const
    {
        return self->data();
    }
}


%ignore eprosima::test::KeyedCompleteTestType::array_bool_field(std::array<bool, max_array_size>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::array_bool_field() const;
%template(bool_3_array) std::array<bool,3>;
%extend std::array<bool, 3>
{
    const bool* get_buffer() const
    {
        return self->data();
    }
}


%ignore eprosima::test::KeyedCompleteTestType::array_enum_field(std::array<eprosima::test::Color, max_array_size>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::array_enum_field() const;
%template(Color_3_array) std::array<enum eprosima::test::Color,3>;
%extend std::array<enum eprosima::test::Color, 3>
{
    const enum eprosima::test::Color* get_buffer() const
    {
        return self->data();
    }
}


%ignore eprosima::test::KeyedCompleteTestType::array_enum2_field(std::array<eprosima::test::Material, max_array_size>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::array_enum2_field() const;
%template(Material_3_array) std::array<enum eprosima::test::Material,3>;
%extend std::array<enum eprosima::test::Material, 3>
{
    const enum eprosima::test::Material* get_buffer() const
    {
        return self->data();
    }
}


%ignore eprosima::test::KeyedCompleteTestType::array_struct_field(std::array<eprosima::test::StructType, max_array_size>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::array_struct_field() const;
%template(StructType_3_array) std::array<eprosima::test::StructType,3>;


%ignore eprosima::test::KeyedCompleteTestType::bounded_sequence_char_field(std::vector<char>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::bounded_sequence_char_field() const;
%extend std::vector<char>
{
    const char* get_buffer() const
    {
        return self->data();
    }
}

%template(char_vector) std::vector<char>;


%ignore eprosima::test::KeyedCompleteTestType::bounded_sequence_uint8_field(std::vector<uint8_t>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::bounded_sequence_uint8_field() const;
%extend std::vector<uint8_t>
{
    const uint8_t* get_buffer() const
    {
        return self->data();
    }
}

%template(uint8_t_vector) std::vector<uint8_t>;


%ignore eprosima::test::KeyedCompleteTestType::bounded_sequence_int16_field(std::vector<int16_t>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::bounded_sequence_int16_field() const;
%extend std::vector<int16_t>
{
    const int16_t* get_buffer() const
    {
        return self->data();
    }
}

%template(int16_t_vector) std::vector<int16_t>;


%ignore eprosima::test::KeyedCompleteTestType::bounded_sequence_uint16_field(std::vector<uint16_t>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::bounded_sequence_uint16_field() const;
%extend std::vector<uint16_t>
{
    const uint16_t* get_buffer() const
    {
        return self->data();
    }
}

%template(uint16_t_vector) std::vector<uint16_t>;


%ignore eprosima::test::KeyedCompleteTestType::bounded_sequence_int32_field(std::vector<int32_t>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::bounded_sequence_int32_field() const;
%extend std::vector<int32_t>
{
    const int32_t* get_buffer() const
    {
        return self->data();
    }
}

%template(int32_t_vector) std::vector<int32_t>;


%ignore eprosima::test::KeyedCompleteTestType::bounded_sequence_uint32_field(std::vector<uint32_t>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::bounded_sequence_uint32_field() const;
%extend std::vector<uint32_t>
{
    const uint32_t* get_buffer() const
    {
        return self->data();
    }
}

%template(uint32_t_vector) std::vector<uint32_t>;


%ignore eprosima::test::KeyedCompleteTestType::bounded_sequence_int64_field(std::vector<int64_t>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::bounded_sequence_int64_field() const;
%extend std::vector<int64_t>
{
    const int64_t* get_buffer() const
    {
        return self->data();
    }
}

%template(int64_t_vector) std::vector<int64_t>;


%ignore eprosima::test::KeyedCompleteTestType::bounded_sequence_uint64_field(std::vector<uint64_t>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::bounded_sequence_uint64_field() const;
%extend std::vector<uint64_t>
{
    const uint64_t* get_buffer() const
    {
        return self->data();
    }
}

%template(uint64_t_vector) std::vector<uint64_t>;


%ignore eprosima::test::KeyedCompleteTestType::bounded_sequence_float_field(std::vector<float>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::bounded_sequence_float_field() const;
%extend std::vector<float>
{
    const float* get_buffer() const
    {
        return self->data();
    }
}

%template(float_vector) std::vector<float>;


%ignore eprosima::test::KeyedCompleteTestType::bounded_sequence_double_field(std::vector<double>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::bounded_sequence_double_field() const;
%extend std::vector<double>
{
    const double* get_buffer() const
    {
        return self->data();
    }
}

%template(double_vector) std::vector<double>;


%ignore eprosima::test::KeyedCompleteTestType::bounded_sequence_bool_field(std::vector<bool>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::bounded_sequence_bool_field() const;
%template(bool_vector) std::vector<bool>;


%ignore eprosima::test::KeyedCompleteTestType::bounded_sequence_enum_field(std::vector<eprosima::test::Color>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::bounded_sequence_enum_field() const;
%extend std::vector<eprosima::test::Color>
{
    const eprosima::test::Color* get_buffer() const
    {
        return self->data();
    }
}

%template(Color_vector) std::vector<enum eprosima::test::Color>;


%ignore eprosima::test::KeyedCompleteTestType::bounded_sequence_enum2_field(std::vector<eprosima::test::Material>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::bounded_sequence_enum2_field() const;
%extend std::vector<eprosima::test::Material>
{
    const eprosima::test::Material* get_buffer() const
    {
        return self->data();
    }
}

%template(Material_vector) std::vector<enum eprosima::test::Material>;


%ignore eprosima::test::KeyedCompleteTestType::bounded_sequence_struct_field(std::vector<eprosima::test::StructType>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::bounded_sequence_struct_field() const;
%template(StructType_vector) std::vector<eprosima::test::StructType>;


%ignore eprosima::test::KeyedCompleteTestType::unbounded_sequence_char_field(std::vector<char>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::unbounded_sequence_char_field() const;
%extend std::vector<char>
{
    const char* get_buffer() const
    {
        return self->data();
    }
}

%template(char_vector) std::vector<char>;


%ignore eprosima::test::KeyedCompleteTestType::unbounded_sequence_uint8_field(std::vector<uint8_t>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::unbounded_sequence_uint8_field() const;
%extend std::vector<uint8_t>
{
    const uint8_t* get_buffer() const
    {
        return self->data();
    }
}

%template(uint8_t_vector) std::vector<uint8_t>;


%ignore eprosima::test::KeyedCompleteTestType::unbounded_sequence_int16_field(std::vector<int16_t>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::unbounded_sequence_int16_field() const;
%extend std::vector<int16_t>
{
    const int16_t* get_buffer() const
    {
        return self->data();
    }
}

%template(int16_t_vector) std::vector<int16_t>;


%ignore eprosima::test::KeyedCompleteTestType::unbounded_sequence_uint16_field(std::vector<uint16_t>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::unbounded_sequence_uint16_field() const;
%extend std::vector<uint16_t>
{
    const uint16_t* get_buffer() const
    {
        return self->data();
    }
}

%template(uint16_t_vector) std::vector<uint16_t>;


%ignore eprosima::test::KeyedCompleteTestType::unbounded_sequence_int32_field(std::vector<int32_t>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::unbounded_sequence_int32_field() const;
%extend std::vector<int32_t>
{
    const int32_t* get_buffer() const
    {
        return self->data();
    }
}

%template(int32_t_vector) std::vector<int32_t>;


%ignore eprosima::test::KeyedCompleteTestType::unbounded_sequence_uint32_field(std::vector<uint32_t>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::unbounded_sequence_uint32_field() const;
%extend std::vector<uint32_t>
{
    const uint32_t* get_buffer() const
    {
        return self->data();
    }
}

%template(uint32_t_vector) std::vector<uint32_t>;


%ignore eprosima::test::KeyedCompleteTestType::unbounded_sequence_int64_field(std::vector<int64_t>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::unbounded_sequence_int64_field() const;
%extend std::vector<int64_t>
{
    const int64_t* get_buffer() const
    {
        return self->data();
    }
}

%template(int64_t_vector) std::vector<int64_t>;


%ignore eprosima::test::KeyedCompleteTestType::unbounded_sequence_uint64_field(std::vector<uint64_t>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::unbounded_sequence_uint64_field() const;
%extend std::vector<uint64_t>
{
    const uint64_t* get_buffer() const
    {
        return self->data();
    }
}

%template(uint64_t_vector) std::vector<uint64_t>;


%ignore eprosima::test::KeyedCompleteTestType::unbounded_sequence_float_field(std::vector<float>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::unbounded_sequence_float_field() const;
%extend std::vector<float>
{
    const float* get_buffer() const
    {
        return self->data();
    }
}

%template(float_vector) std::vector<float>;


%ignore eprosima::test::KeyedCompleteTestType::unbounded_sequence_double_field(std::vector<double>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::unbounded_sequence_double_field() const;
%extend std::vector<double>
{
    const double* get_buffer() const
    {
        return self->data();
    }
}

%template(double_vector) std::vector<double>;


%ignore eprosima::test::KeyedCompleteTestType::unbounded_sequence_bool_field(std::vector<bool>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::unbounded_sequence_bool_field() const;
%template(bool_vector) std::vector<bool>;


%ignore eprosima::test::KeyedCompleteTestType::unbounded_sequence_enum_field(std::vector<eprosima::test::Color>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::unbounded_sequence_enum_field() const;
%extend std::vector<eprosima::test::Color>
{
    const eprosima::test::Color* get_buffer() const
    {
        return self->data();
    }
}

%template(Color_vector) std::vector<enum eprosima::test::Color>;


%ignore eprosima::test::KeyedCompleteTestType::unbounded_sequence_enum2_field(std::vector<eprosima::test::Material>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::unbounded_sequence_enum2_field() const;
%extend std::vector<eprosima::test::Material>
{
    const eprosima::test::Material* get_buffer() const
    {
        return self->data();
    }
}

%template(Material_vector) std::vector<enum eprosima::test::Material>;


%ignore eprosima::test::KeyedCompleteTestType::unbounded_sequence_struct_field(std::vector<eprosima::test::StructType>&&);


// Overloaded getter methods shadow each other and are equivalent in python
// Const accesors produced constant enums instead of arrays/dictionaries when used
// We ignore them to prevent this
%ignore eprosima::test::KeyedCompleteTestType::unbounded_sequence_struct_field() const;
%template(StructType_vector) std::vector<eprosima::test::StructType>;


%template(_KeyedCompleteTestTypeSeq) eprosima::fastdds::dds::LoanableTypedCollection<eprosima::test::KeyedCompleteTestType, std::false_type>;
%template(KeyedCompleteTestTypeSeq) eprosima::fastdds::dds::LoanableSequence<eprosima::test::KeyedCompleteTestType, std::false_type>;
%extend eprosima::fastdds::dds::LoanableSequence<eprosima::test::KeyedCompleteTestType, std::false_type>
{
    size_t __len__() const
    {
        return self->length();
    }

    const eprosima::test::KeyedCompleteTestType& __getitem__(size_t i) const
    {
        return (*self)[i];
    }
}




// Include the class interfaces
%include "test_modules.h"
%include "test_modulesv1.h"

// Include the corresponding TopicDataType
%include "test_modulesPubSubTypes.i"

